use crate::jtool::file;
use crate::jtool::run_context;
use serde::{Deserialize, Serialize};
use serde_json::Result;
use std::{env::consts::FAMILY, io::{Read, Write}};
#[derive(PartialEq, Eq, Serialize, Deserialize)]
pub struct Config {
    config: Option<Vec<ConfigGroup>>,
}

#[derive(PartialEq, Eq, Serialize, Deserialize)]
pub struct ConfigGroup {
    config_name: String,
    data: Vec<ConfigItem>,
}

#[derive(PartialEq, Eq, Serialize, Deserialize)]
pub struct ConfigItem {
    key: String,
    value: String,
}

// pub fn set_config(config_name: String, key: String, value: String) -> bool {
//     // let mut m_config_name = config_name;
//     // let mut m_key = key;
//     // let mut m_value = value;

//     let mut config: Config = get_config_object();

//     if config.config == None {
//         let mut configItem: ConfigItem = ConfigItem {
//             key: key.clone(),
//             value: value.clone(),
//         };
//         let mut itemVec: Vec<ConfigItem> = Vec::new();
//         itemVec.push(configItem);

//         let mut configGroup: ConfigGroup = ConfigGroup {
//             config_name: config_name.clone(),
//             data: itemVec,
//         };

//         let mut configVec: Vec<ConfigGroup> = Vec::new();
//         configVec.push(configGroup);

//         config.config = Some(configVec);

//         let serialized = serde_json::to_string(&config).unwrap();
//         save_config(serialized);
//     } else {
//         for mut group in config.config.unwrap() {
//             if group.config_name == config_name.clone() {
//                 let mut isHaveItem = false;
//                 for mut item in group.data {
//                     if item.key == key.clone() {
//                         item.value = value.clone();
//                         isHaveItem = true;
//                     }
//                 }
//                 if !isHaveItem {
//                     let mut configItem: ConfigItem = ConfigItem {
//                         key: key.clone(),
//                         value: value.clone(),
//                     };
//                     group.data.push(configItem);
//                 }
//             }
//         }
//     }
//     return false;
// }

pub fn get_config_object() -> Config {
    let path = run_context::get_run_dir();
    let file_path = path.to_string() + "\\j_rust_config.json";

    let file_exist = file::is_exist(&file_path);
    if !file_exist {
        file::create_file(&file_path);

        // Some data structure.
        let config = Config { config: None };

        // Serialize it to a JSON string.
        let j = serde_json::to_string(&config);
        match j {
            Ok(text) => {
                let mut txt = std::fs::File::create(file_path).expect("create failed");
                txt.write_all(text.as_bytes()).expect("write failed");
            }
            Err(error) => {}
        }

        return config;
    } else {
        let mut txt = std::fs::File::open(file_path).unwrap();
        let mut contents = String::new();
        txt.read_to_string(&mut contents).unwrap();
        let config: Config = serde_json::from_str(&contents).unwrap();
        return config;
    }
}

fn save_config(content: String) {
    let path = run_context::get_run_dir();
    let file_path = path.to_string() + "\\j_rust_config.json";
    let mut txt = std::fs::File::create(file_path).expect("create failed");
    txt.write_all(content.as_bytes()).expect("write failed");
}
